package rq.optimize.luban;

import android.graphics.Bitmap;
import android.os.Environment;
import android.text.TextUtils;
import android.util.Base64;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 文件工具类
 *
 * @author 孙青龙 E-mail:0731@aliyun.com 电话：15580921525
 * @version 创建时间：2017-1-20 上午8:13:01
 */
class FileUtils {
    private String SDPATH;

    public FileUtils() {
        //得到当前外部存储设备的目录
        // /SDCARD
        SDPATH = Environment.getExternalStorageDirectory() + "/";
    }

    /**
     * 删除指定文件
     *
     * @param file
     * @return
     * @throws IOException
     */
    public static boolean deleteFile(File file) throws IOException {
        return deleteFileOrDirectory(file);
    }

    /**
     * 删除指定文件，如果是文件夹，则递归删除
     *
     * @param file
     * @return
     * @throws IOException
     */
    public static boolean deleteFileOrDirectory(File file) throws IOException {
        try {
            if (file != null && file.isFile()) {
                return file.delete();
            }
            if (file != null && file.isDirectory()) {
                File[] childFiles = file.listFiles();
                // 删除空文件夹
                if (childFiles == null || childFiles.length == 0) {
                    return file.delete();
                }
                // 递归删除文件夹下的子文件
                for (int i = 0; i < childFiles.length; i++) {
                    deleteFileOrDirectory(childFiles[i]);
                }
                return file.delete();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /***
     * 获取文件扩展名
     *
     * @param filename
     *            文件名
     * @return
     */
    public static String getExtensionName(String filename) {
        if ((filename != null) && (filename.length() > 0)) {
            int dot = filename.lastIndexOf('.');
            if ((dot > -1) && (dot < (filename.length() - 1))) {
                return filename.substring(dot + 1);
            }
        }
        return filename;
    }

    /**
     * 获取文件内容
     *
     * @param path
     * @return
     */
    public static String getFileOutputString(String path) {
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(
                    path), 8192);
            StringBuilder sb = new StringBuilder();
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                sb.append("\n").append(line);
            }
            bufferedReader.close();
            return sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 判断目录是否存在并创建单级目录
     *
     * @param strFolder
     * @return
     */
    public static boolean isFolderExists(String strFolder) {
        File file = new File(strFolder);

        if (!file.exists()) {
            return file.mkdir();
        }
        return true;
    }

    /**
     * 判断目录是否存在并创建多级目录
     *
     * @param strFolder
     * @return
     */
    public static boolean isFolderExistss(String strFolder) {
        File file = new File(strFolder);
        if (!file.exists()) {
            return file.mkdirs();
        }
        return true;
    }

    /**
     * 复制单个文件
     *
     * @param oldPath String 原文件路径 如：c:/fqf.txt
     * @param newPath String 复制后路径 如：f:/fqf.txt
     * @return boolean
     */
    public static boolean copyFile(String oldPath, String newPath) {
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPath);
            if (oldfile.exists()) { //文件存在时
                InputStream inStream = new FileInputStream(oldPath); //读入原文件
                FileOutputStream fs = new FileOutputStream(newPath);
                byte[] buffer = new byte[1444];
                while ((byteread = inStream.read(buffer)) != -1) {
                    bytesum += byteread; //字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * @param path 文件所在目录,注:不会递归删除
     * @param days 文件有效时间 (天)
     * @return
     */
    public static boolean deletExpireFile(String path, int days) {
        File file = new File(path);
        if (file.isDirectory()) {
            File[] listFile = file.listFiles();
            if (listFile.length > 0) {
                int length = listFile.length;
                for (int i = 0; i < length; i++) {
                    if (listFile[i].exists()) {
                        Long s = (System.currentTimeMillis() - listFile[i].lastModified()) / (1000 * 60 * 60 * 24);
                        if (s > days) {
                            listFile[i].delete();
                        }
                    }
                }
            }
        }
        return true;
    }

    /**
     * 用以查询模糊头部为str的文件
     *
     * @param path 文件夹的路径
     * @param str  str:要匹配的字符串的头
     * @return
     * @author 孙青龙 E-mail:0731@aliyun.com 电话：15580921525
     * @version 创建时间：2017-1-22 上午11:49:43
     */
    public static String findFilesByPath(String path, String str) {
        if (str == null || str.equals("") || path == null || path.equals("")) {
            return null;
        }
        File file = new File(path);
        if (file != null && file.exists()) {
            File[] tempFile = file.listFiles();
            for (int i = 0; i < tempFile.length; i++) {
                if (tempFile[i].getName().startsWith(str)
                        || tempFile[i].getName().endsWith(str)) {
                    return path + tempFile[i].getName();
                }
            }
        }
        return null;
    }

    /**
     * 用以查询模糊头部为str的文件夹
     *
     * @param dir_name 文件夹地址
     * @param str      str:要匹配的字符串的头
     * @author 孙青龙 E-mail:0731@aliyun.com 电话：15580921525
     * @version 创建时间：2017-1-22 上午11:49:43
     */
    public static String findDirByPath(String dir_name, String str) {
        if (str == null || str.equals("") || dir_name == null || dir_name.equals("")) {
            return null;
        }
        File[] files = new File(dir_name).listFiles(); //获取该文件夹下所有的文件(夹)名
        int len = files.length;
        for (int i = 0; i < len; i++) {
            String tmp = files[i].getAbsolutePath();
            if (files[i].isDirectory()) { //是目录
                if (tmp.contains(str))
                    return tmp;
            }
        }
        return null;
    }

    /**
     * 将图片转换成Base64编码的字符串
     *
     * @param path
     * @return base64编码的字符串
     */
    public static String imageToBase64(String path) {
        if (TextUtils.isEmpty(path)) {
            return null;
        }
        InputStream is = null;
        byte[] data = null;
        String result = null;
        try {
            is = new FileInputStream(path);
            //创建一个字符流大小的数组。
            data = new byte[is.available()];
            //写入数组
            is.read(data);
            //用默认的编码格式进行编码
            result = Base64.encodeToString(data, Base64.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return result;
    }

    /**
     * 图片文件转Base64字符串 * @param path 文件所在的绝对路径加文件名　 * @return
     */
    public static String fileBase64String(String path) {
        try {
            FileInputStream fis = new FileInputStream(path);
            //转换成输入流
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int count = 0;
            while ((count = fis.read(buffer)) >= 0) {
                baos.write(buffer, 0, count);//读取输入流并写入输出字节流中
            }
            fis.close();
            //关闭文件输入流
            String uploadBuffer = Base64.encodeToString(baos.toByteArray(), Base64.DEFAULT); //进行Base64编
            return uploadBuffer;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 通过Base32将Bitmap转换成Base64字符串
     *
     * @param bit
     * @return
     */
    public static String Bitmap2StrByBase64(Bitmap bit) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bit.compress(Bitmap.CompressFormat.JPEG, 40, bos);//参数100表示不压缩
        byte[] bytes = bos.toByteArray();
        return Base64.encodeToString(bytes, Base64.DEFAULT);
    }

    /**
     * base64编码字符集转化成图片文件。
     *
     * @param base64Str
     * @param path      文件存储路径
     * @return 是否成功
     */
    public static boolean base64ToFile(String base64Str, String path) {
        byte[] data = Base64.decode(base64Str, Base64.DEFAULT);
        for (int i = 0; i < data.length; i++) {
            if (data[i] < 0) {
                //调整异常数据
                data[i] += 256;
            }
        }
        OutputStream os = null;
        try {
            os = new FileOutputStream(path);
            os.write(data);
            os.flush();
            os.close();
            return true;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * base64转为bitmap
     *
     * @param base64Data
     * @return
     */
    public static byte[] base64ToBitmap(String base64Data) {
        byte[] bytes = Base64.decode(base64Data, Base64.DEFAULT);
        return bytes;
        //BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
    }

    /**
     * 读取文件的大小
     */

    public static long getFileSize(File f) {
        long l = 0;
        try {
            if (f.exists()) {
                FileInputStream mFIS = new FileInputStream(f);
                l = mFIS.available();
            } else {
                f.createNewFile();
            }
        } catch (Exception e) {

        }

        return l;
    }

    public String getSDPATH() {
        return SDPATH;
    }

    /**
     * 在SD卡上创建文件
     *
     * @throws IOException
     */
    public File creatSDFile(String fileName) throws IOException {
        File file = new File(SDPATH + fileName);
        file.createNewFile();
        return file;
    }

    /**
     * 在SD卡上创建目录
     *
     * @param dirName
     */
    public File creatSDDir(String dirName) {
        File dir = new File(SDPATH + dirName);
        dir.mkdirs();
        return dir;
    }

    /**
     * 判断SD卡上的文件夹是否存在
     */
    public boolean isFileExist(String fileName) {
        File file = new File(SDPATH + fileName);
        return file.exists();
    }

    /**
     * 将一个InputStream里面的数据写入到SD卡中
     */
    public File write2SDFromInput(String path, String fileName, InputStream input) {
        File file = null;
        OutputStream output = null;
        try {
            creatSDDir(path);
            file = creatSDFile(path + fileName);
            output = new FileOutputStream(file);
            byte[] buffer = new byte[4 * 1024];
            while ((input.read(buffer)) != -1) {
                output.write(buffer);
            }
            output.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                output.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return file;
    }
}
